package com.agencia.persistencia;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;

import com.agencia.connection.DataSocketBuscar;
import com.agencia.dominio.Anulado;
import com.agencia.dominio.Terminal;
import com.agencia.dominio.Usuario;
import com.agencia.dominio.Venta;

public class PersistenciaImp implements IPersistencia {
	
	private PersistenciaImp(){};
	
	private static PersistenciaImp instancia = new PersistenciaImp();
	
	public static PersistenciaImp getInstance(){
		return instancia;
	}

	public Venta altaVentaBD(Venta venta) throws SQLException	{ 
		
		String sql_idVenta = "SELECT Valor FROM Configuracion WHERE parametro = ? LIMIT 1";
		String sql_updidVenta = "UPDATE Configuracion SET Valor = ? WHERE parametro=?";
		String sql_addVenta="INSERT INTO Ventas (Id_Ticket, " +
				"Id_Ticket_IMM, " +
				"Matricula, " +
				"FechaVenta, " +
				"FechaInicio, " +
				"Minutos, " +
				"Importe, " +
				"Id_Terminal, " +
				"Id_Usuario) " +
				"VALUES (?, ?, TRIM(?), ?, ?, ?, ?, ?, ?)";

		Integer idVenta = 0;
		
		PreparedStatement ps_idVenta = null;
		PreparedStatement ps_updidVenta = null;
		PreparedStatement ps_addVenta = null;
		
		Connection con = null;
		ResultSet rs_idVenta = null;
		
		con = DBConn.DataSourceCon();
		con.setAutoCommit(false);
		
		ps_idVenta = con.prepareStatement(sql_idVenta);
		ps_updidVenta = con.prepareStatement(sql_updidVenta);
		ps_addVenta = con.prepareStatement(sql_addVenta);

		ps_idVenta.setString(1,Constants.getIdVentas());
		
		rs_idVenta = ps_idVenta.executeQuery();
		
		while(rs_idVenta.next()) {
			idVenta  = rs_idVenta.getInt("Valor");
		}
		//INCREMENTO Id_Anulado
		idVenta +=1;
		
		ps_updidVenta.setInt(1, idVenta);
		ps_updidVenta.setString(2, Constants.getIdVentas());
		
		ps_addVenta.setInt(1, idVenta);
		ps_addVenta.setInt(2, venta.getId_imm());
		ps_addVenta.setString(3, venta.getMatricula());
		ps_addVenta.setTimestamp(4,  new Timestamp(venta.getFechaVenta().getTime()));
		ps_addVenta.setTimestamp(5, new Timestamp(venta.getFechaInicio().getTime()));
		ps_addVenta.setInt(6, venta.getMinutos());
		ps_addVenta.setDouble(7, venta.getImporte());
		ps_addVenta.setInt(8, venta.getId_terminal());
		ps_addVenta.setInt(9, venta.getId_usuario());

		ps_updidVenta.executeUpdate();
		ps_addVenta.executeUpdate();

		con.commit();
		con.setAutoCommit(true);
		
		ps_addVenta.close();
		ps_idVenta.close();
		ps_updidVenta.close();

		rs_idVenta.close();
		
		if(con != null) con.close();

		venta.setId(idVenta);
		
		
		return venta;
		

	}

	public Anulado anularVentaBD(Venta venta, Anulado anulado) throws SQLException {
		String sql_idAnulado = "SELECT Valor FROM Configuracion WHERE parametro = ? LIMIT 1";
		String sql_updidAnulado = "UPDATE Configuracion SET Valor = ? WHERE parametro=?";
		String sql_addAnulado="INSERT INTO Anulaciones (Id_Ticket, Id_Anulado, Id_Anulado_IMM, Fecha, Id_Usuario) VALUES (?, ?, ?, ?, ?)";
		Integer idAnulado = 0;
		Date fechaactual = new Date();
		Timestamp fechaActual = new Timestamp(fechaactual.getTime());
		
		
		PreparedStatement ps_idAnulado = null;
		PreparedStatement ps_updidAnulado = null;
		PreparedStatement ps_addAnulado = null;
		
		Connection con = null;
		ResultSet rs_idAnulado = null;
		
		
		con = DBConn.DataSourceCon();
		con.setAutoCommit(false);
		
		ps_idAnulado = con.prepareStatement(sql_idAnulado);
		ps_updidAnulado = con.prepareStatement(sql_updidAnulado);
		ps_addAnulado = con.prepareStatement(sql_addAnulado);

		ps_idAnulado.setString(1,Constants.getIdAnulaciones());
		
		rs_idAnulado = ps_idAnulado.executeQuery();
		
		while(rs_idAnulado.next()) {
			idAnulado  = rs_idAnulado.getInt("Valor");
		}
		//INCREMENTO Id_Anulado
		idAnulado +=1;
		
		ps_updidAnulado.setInt(1, idAnulado);
		ps_updidAnulado.setString(2, Constants.getIdAnulaciones());
		
		ps_addAnulado.setInt(1, venta.getId());
		ps_addAnulado.setInt(2, idAnulado);
		ps_addAnulado.setInt(3, anulado.getId());
		ps_addAnulado.setTimestamp(4, fechaActual);
		ps_addAnulado.setInt(5, venta.getId_usuario());
		
		ps_updidAnulado.executeUpdate();
		ps_addAnulado.executeUpdate();

		con.commit();
		con.setAutoCommit(true);
		
		ps_addAnulado.close();
		ps_updidAnulado.close();
		ps_idAnulado.close();
		rs_idAnulado.close();
		
		if(con != null) con.close();

		return anulado;
	}

	public boolean ingresarUsuarioBD(Usuario usuario) { //sdc 12/11/12
		String sql_idUsuario = "SELECT Valor FROM Configuracion WHERE Parametro=? LIMIT 1";
		String sql_updidUsuario = "UPDATE Configuracion SET Valor = ? WHERE parametro=?";
		String sql_addUsuario = "INSERT INTO Usuarios (Id, Nombre, Usuario, Password) VALUES(?, ?, ?, MD5(?))";
		Integer id_Usuario = 0;
		
		PreparedStatement ps_idUsuario = null;
		PreparedStatement ps_updidUsuario = null;
		PreparedStatement ps_addUsuario = null;
		
		Connection con = null;
		ResultSet rs_idUsuario = null;
		
		
		try {
			con = DBConn.DataSourceCon();
			con.setAutoCommit(false);
			ps_idUsuario = con.prepareStatement(sql_idUsuario);
			ps_updidUsuario = con.prepareStatement(sql_updidUsuario);
			ps_addUsuario = con.prepareStatement(sql_addUsuario);
					
			ps_idUsuario.setString(1,Constants.getIdUsuarios());
			
			rs_idUsuario = ps_idUsuario.executeQuery();
			
			while(rs_idUsuario.next()) {
				id_Usuario  = rs_idUsuario.getInt("Valor");
			}
			//INCREMENTO Id_Usuario
			id_Usuario +=1;
			
			ps_updidUsuario.setInt(1, id_Usuario);
			ps_updidUsuario.setString(2, Constants.getIdUsuarios());
			
			ps_addUsuario.setInt(1, id_Usuario);
			ps_addUsuario.setString(2, usuario.getNombre());
			ps_addUsuario.setString(3, usuario.getUsuario());
			ps_addUsuario.setString(4, usuario.getPass());
			
			ps_updidUsuario.executeUpdate();
			ps_addUsuario.executeUpdate();

			con.commit();
			con.setAutoCommit(true);
			
			ps_addUsuario.close();
			rs_idUsuario.close();
			if(con != null) con.close();

			
			

		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		return true;
				
	}

	public boolean modificarUsuarioBD(Usuario usuario) throws SQLException {
		String sql_updUsuario = "UPDATE Usuarios SET Nombre = ?, Usuario = ?, Password = MD5(?) WHERE Id=?";				
				
		
		PreparedStatement ps_updUsuario = null;
		
		Connection con = null;
		
		con = DBConn.DataSourceCon();
		con.setAutoCommit(false);
		try {
			ps_updUsuario = con.prepareStatement(sql_updUsuario);
			
			ps_updUsuario.setString(1, usuario.getNombre());
			ps_updUsuario.setString(2, usuario.getUsuario());
			ps_updUsuario.setString(3, usuario.getPass());
			ps_updUsuario.setInt(4, usuario.getId());
			
			ps_updUsuario.executeUpdate();
			
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		

		con.commit();
		con.setAutoCommit(true);
		
		ps_updUsuario.close();
		if(con != null) con.close();

	
		return true;
	}
	
	public boolean ingresarTerminalaBD(Terminal terminal) throws TerminalExisteException, TerminalErrorDatosException, SQLException {
		// TODO Auto-generated method stub
		
		if(terminal == null){
			
		}else if(terminal.getDomicilio().equalsIgnoreCase("") || terminal.getNombre().equalsIgnoreCase("") || terminal.getTelefono().equalsIgnoreCase("")){
			throw new TerminalErrorDatosException();
		}else{
			/*
			if(buscarTerminalaBD(terminal.getId()).getId()!= null){
				throw new TerminalExisteException();
			}*/
			//String sql_idTerminal = "SELECT valor FROM Configuracion WHERE parametro='"+ Constants.getIdTerminal()+"' LIMIT 1";
			
			String sql_idTerminal = "SELECT Valor FROM Configuracion WHERE Parametro='Id_Terminales' LIMIT 1";
			
			Double id_idTerminal = (double) 1;
			
			PreparedStatement ps = null;
			PreparedStatement ps1 = null;
			Connection con = null;
			Statement stmt = null;
			ResultSet rs_idTerminal = null;
			
			con = DBConn.DataSourceCon();
			con.setAutoCommit(false);
			
			try {
				stmt = con.createStatement();
				rs_idTerminal = stmt.executeQuery(sql_idTerminal);
				
				while(rs_idTerminal.next()) {
					id_idTerminal = Double.valueOf(rs_idTerminal.getString("Valor")); //.valueOf(rs_idTerminal.getString("valor"));
				}
				id_idTerminal +=1;
				
				String sql_addterminal = "INSERT INTO Terminales (id, nombre, domicilio, telefono) VALUES(?, ?, ?, ?)";
				String sql_increidterminal = "UPDATE Configuracion SET Valor =" + id_idTerminal.toString() + " WHERE Parametro='"+Constants.getIdTerminal()+"'";
				
			
				ps1 = con.prepareStatement(sql_increidterminal);
				ps = con.prepareStatement(sql_addterminal);
				ps.setDouble(1, id_idTerminal);            //(id_idTerminal, 1000);
				ps.setString(2, terminal.getNombre());
				ps.setString(3, terminal.getDomicilio());
				ps.setString(4, terminal.getTelefono());
				ps1.executeUpdate();
				
				ps.executeUpdate();
				
				
						
				con.commit();
				return true;
				
			} catch (Exception e) {
				//FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(),""));
				System.out.println(e.getMessage());
				return false;
						
			}finally {
				if(rs_idTerminal != null) rs_idTerminal.close();
				if(stmt != null) stmt.close();
				con.setAutoCommit(true);
				if(con != null) con.close();
				
			}
		}
		return false;
	}

	public boolean modificarTerminalBD(Terminal terminal){
	
		String sql_updTerminal = "UPDATE Terminales SET Nombre = ?, Domicilio = ?, Telefono = ? WHERE Id = ?";
		
		//UPDATE `cobranza_agencia`.`terminales` SET `Nombre`='dsfs', `Domicilio`='sadfs', `Telefono`='1' WHERE `Id`='6';


		
		PreparedStatement ps_updTerminal = null;
		Connection con = null;
		try {
			con = DBConn.DataSourceCon();
			con.setAutoCommit(false);
		
			ps_updTerminal = con.prepareStatement(sql_updTerminal);
			
			ps_updTerminal.setString(1, terminal.getNombre());
			ps_updTerminal.setString(2, terminal.getDomicilio());
			ps_updTerminal.setString(3, terminal.getTelefono());
			ps_updTerminal.setInt(4, terminal.getId());
			
			ps_updTerminal.executeUpdate();

			con.commit();
			con.setAutoCommit(true);
			
			ps_updTerminal.close();

			con.commit();
			con.setAutoCommit(true);
			
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}finally{
			try {
				ps_updTerminal.close();
				con.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		return true;
	}

	public boolean existeUsuarioTerminalBD(String us, String pass,int id_terminal) throws SQLException {
		
		String sql_ExisteUsrTer = "SELECT COUNT(Usuarios.Id) AS Cantidad "; 
		sql_ExisteUsrTer += " FROM Usuarios JOIN Usuario_Terminal ON Usuario_Terminal.Id_Usuario = Usuarios.Id ";
		sql_ExisteUsrTer += " WHERE Usuarios.Usuario = ? AND Usuarios.Password = MD5(?) AND Usuario_Terminal.Id_Terminal = ?";
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_eUser = null;
		Integer count = 0;
		
		con = DBConn.DataSourceCon();

		sql_statement = con.prepareStatement(sql_ExisteUsrTer);
		sql_statement.setString(1, us); 
		sql_statement.setString(2, pass);
		sql_statement.setInt(3, id_terminal);
		
		rs_eUser = sql_statement.executeQuery();
		rs_eUser.next();
		
		count = rs_eUser.getInt("Cantidad");
		rs_eUser.close();
		con.close();
		
		if(count!=0){
			return true;
		}else{
			return false;
		}
	}
	
	public Terminal buscarTerminalaBD(Integer id_Terminal) throws SQLException {
		
		Terminal terminal = new Terminal();
		
		String sql_Terminal = "SELECT 	Id," +
				"Nombre," +
				"Domicilio," +
				"Telefono " +
				"FROM Terminales " +
				"WHERE Id = ?";
		
		PreparedStatement ps_Terminal = null;
		Connection con = null;
		ResultSet rs_eTerminal = null;
		
		con = DBConn.DataSourceCon();

		ps_Terminal = con.prepareStatement(sql_Terminal);
		ps_Terminal.setInt(1, id_Terminal); 
		
		rs_eTerminal = ps_Terminal.executeQuery();
		
		while(rs_eTerminal.next()){
			terminal.setId(rs_eTerminal.getInt("Id"));
			terminal.setNombre(rs_eTerminal.getString("Nombre"));
			terminal.setDomicilio(rs_eTerminal.getString("Domicilio"));
			terminal.setTelefono(rs_eTerminal.getString("Telefono"));
		}
		ps_Terminal.close();
		rs_eTerminal.close();
		con.close();
		
		return terminal;
	}

	public boolean loginAdminBD(String us, String pass) throws SQLException {
		
		String sql_idTerminalAdm = "SELECT Valor FROM Configuracion WHERE Parametro=? LIMIT 1";
		
		PreparedStatement ps_statement = null;
		Connection con = null;
		ResultSet rs_idTerminalAdm = null;
		Integer id_TerminalAdm = null;
		
		con = DBConn.DataSourceCon();
		
		ps_statement = con.prepareStatement(sql_idTerminalAdm);
		ps_statement.setString(1, Constants.getTerminalAdministrativa());
		
		rs_idTerminalAdm = ps_statement.executeQuery();
		
		while(rs_idTerminalAdm.next()) {
			id_TerminalAdm  = rs_idTerminalAdm.getInt("Valor");
		}
		ps_statement.close();
		rs_idTerminalAdm.close();
		con.close();
		
		return existeUsuarioTerminalBD(us, pass, id_TerminalAdm);
		
	}
	
	public ArrayList<Terminal> selectAll() throws SQLException{
		
		ArrayList<Terminal> terminales = new ArrayList<Terminal>();
		String sql_ideditorial = "SELECT Id, Nombre, Domicilio, Telefono FROM Terminales";
		
		Connection con = null;
		Statement stmt = null;
		ResultSet rs = null;
		
		
		con = DBConn.DataSourceCon();
		con.setAutoCommit(false);
		try {
			
			stmt = con.createStatement();
			rs = stmt.executeQuery(sql_ideditorial);
			
			
			
			while (rs.next()){
				Terminal t = new Terminal();
				t.setId(rs.getInt("Id"));
	            t.setNombre(rs.getString("Nombre"));
	            t.setDomicilio(rs.getString("Domicilio"));
	            t.setTelefono(rs.getString("Telefono"));
	            
	            terminales.add(t);
			}
			
			con.commit();
			
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(rs != null) rs.close();
			if(stmt != null) stmt.close();
			con.setAutoCommit(true);
			if(con != null) con.close();
			
		}
		return terminales;
	}

	public Usuario obtenerUsuario(String user) throws SQLException {
		
		String sql_ExisteUsrTer = "SELECT Usuarios.Id AS id, Usuarios.nombre AS nombre "; 
		sql_ExisteUsrTer += " FROM Usuarios";
		sql_ExisteUsrTer += " WHERE Usuarios.Usuario =?";
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_eUser = null;
		Integer id = 0;
		String nombre = "";
		con = DBConn.DataSourceCon();

	
		
			sql_statement = con.prepareStatement(sql_ExisteUsrTer);
			sql_statement.setString(1, user);            
			
			rs_eUser = sql_statement.executeQuery();

			while(rs_eUser.next()){
				id = rs_eUser.getInt("id");
				nombre= rs_eUser.getString("nombre");
			}
			sql_statement.close();
			rs_eUser.close();
			con.close();
			Usuario retorno = new Usuario(id, nombre, user, "");
			return retorno;
	}

	public Integer obtenerAgencia() throws SQLException {

		String sql_Agencia = "SELECT Valor FROM Configuracion WHERE Parametro =?";
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_Agencia = null;
		Integer id = null;
		con = DBConn.DataSourceCon();
		
		sql_statement = con.prepareStatement(sql_Agencia);
		sql_statement.setString(1, Constants.getIdAgencia());            
		
		rs_Agencia = sql_statement.executeQuery();
		
		while(rs_Agencia.next()){
			id = rs_Agencia.getInt("Valor");	
		}
		sql_statement.close();
		rs_Agencia.close();
		con.close();
		
		return id;
	}

	public boolean verificarDatosVentas(Venta venta) throws SQLException {
		
		String sql_ExisteVenta = "SELECT COUNT(Id_Ticket) AS Cantidad " +
				"FROM Ventas " +
				"WHERE Id_Ticket_IMM = ? " +
				"AND Matricula = ?";
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_eUser = null;
		Integer count = 0;
		
		con = DBConn.DataSourceCon();

		sql_statement = con.prepareStatement(sql_ExisteVenta);
		sql_statement.setInt(1, venta.getId_imm());
		sql_statement.setString(2, venta.getMatricula());
		
		rs_eUser = sql_statement.executeQuery();
		rs_eUser.next();
		
		count = rs_eUser.getInt("Cantidad");
		sql_statement.close();
		rs_eUser.close();
		con.close();
		
		if(count!=0){
			return true;
		}else{
			return false;
		}
	}

	public boolean verificarVentaAnulada(Venta venta) throws SQLException {
		// TODO Auto-generated method stub
		String sql_ExisteVenta = "SELECT COUNT(Ventas.Id_Ticket) AS Cantidad " +
				"FROM Anulaciones " +
				"JOIN Ventas ON  Ventas.Id_Ticket=Anulaciones.Id_Ticket " +
				"WHERE Ventas.Id_Ticket_IMM = ? "; 
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_eUser = null;
		Integer count = 0;
		
		con = DBConn.DataSourceCon();

		sql_statement = con.prepareStatement(sql_ExisteVenta);
		sql_statement.setInt(1, venta.getId_imm());
		
		rs_eUser = sql_statement.executeQuery();
		rs_eUser.next();
		
		count = rs_eUser.getInt("Cantidad");
		sql_statement.close();
		rs_eUser.close();
		con.close();
		
		if(count!=0){
			return true;
		}else{
			return false;
		}
	}

	public DataSocketBuscar buscarDataVenta(Integer id_Ticket_IMM) throws SQLException {
		DataSocketBuscar venta = new DataSocketBuscar();
		
		String sql_Venta = "SELECT Ventas.Id_Ticket, " +
				"Ventas.Id_Ticket_IMM, " +
				"Ventas.Matricula, " +
				"Ventas.FechaVenta, " +
				"Ventas.FechaInicio, " +
				"Ventas.Minutos, " +
				"Ventas.Importe, " +
				"Ventas.Id_Terminal, " +
				"Ventas.Id_Usuario, " +
				"Anulaciones.Id_Anulado " +
				"FROM Ventas " +
				"LEFT JOIN Anulaciones ON Anulaciones.Id_Ticket = Ventas.Id_Ticket " +
				"WHERE Ventas.Id_Ticket_IMM = ?";
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_eVenta = null;
		
		con = DBConn.DataSourceCon();

		sql_statement = con.prepareStatement(sql_Venta);
		sql_statement.setInt(1, id_Ticket_IMM); 
		
		rs_eVenta = sql_statement.executeQuery();
		while(rs_eVenta.next()){
			venta.setFechaVenta(rs_eVenta.getDate("FechaVenta"));
			venta.setFechaInicio(rs_eVenta.getDate("FechaInicio"));
			venta.setMinutos(rs_eVenta.getInt("Minutos"));
			venta.setImporte(rs_eVenta.getDouble("Importe"));
			venta.setId_terminal(rs_eVenta.getInt("Id_Terminal"));
			venta.setMatricula(rs_eVenta.getString("Matricula"));
			venta.setError(rs_eVenta.getInt("Id_Anulado"));
		}
		
		sql_statement.close();
		rs_eVenta.close();
		con.close();
		
		return venta;
	}

	public Venta buscarVenta(Integer id_Ticket_IMM) throws SQLException {
		Venta venta = new Venta();
		
		String sql_Venta = "SELECT Ventas.Id_Ticket, " +
				"Ventas.Id_Ticket_IMM, " +
				"Ventas.Matricula, " +
				"Ventas.FechaVenta, " +
				"Ventas.FechaInicio, " +
				"Ventas.Minutos, " +
				"Ventas.Importe, " +
				"Ventas.Id_Terminal, " +
				"Ventas.Id_Usuario " +
				"FROM Ventas " +
				"WHERE Ventas.Id_Ticket_IMM = ?";
		
		PreparedStatement sql_statement = null;
		Connection con = null;
		ResultSet rs_eVenta = null;
		
		con = DBConn.DataSourceCon();

		sql_statement = con.prepareStatement(sql_Venta);
		sql_statement.setInt(1, id_Ticket_IMM); 
		
		rs_eVenta = sql_statement.executeQuery();
		while(rs_eVenta.next()){
			venta.setId(rs_eVenta.getInt("Id_Ticket"));
			venta.setId_imm(rs_eVenta.getInt("Id_Ticket_IMM"));
			venta.setMatricula(rs_eVenta.getString("Matricula"));
			venta.setFechaVenta(rs_eVenta.getDate("FechaVenta"));
			venta.setFechaInicio(rs_eVenta.getDate("FechaInicio"));
			venta.setMinutos(rs_eVenta.getInt("Minutos"));
			venta.setImporte(rs_eVenta.getDouble("Importe"));
			venta.setId_terminal(rs_eVenta.getInt("Id_Terminal"));
			venta.setId_usuario(rs_eVenta.getInt("Id_Usuario"));
		}
		sql_statement.close();
		rs_eVenta.close();
		con.close();
		
		return venta;
	}

	public ArrayList<Usuario> selectAllUsuarios() throws SQLException {
		// TODO Auto-generated method stub
		ArrayList<Usuario> usuarios = new ArrayList<Usuario>();
		String sql_ideditorial = "SELECT Id, Nombre, Usuario FROM Usuarios";
		
		Connection con = null;
		Statement stmt = null;
		ResultSet rs = null;
		
		
		con = DBConn.DataSourceCon();
		con.setAutoCommit(false);
		try {
			
			stmt = con.createStatement();
			rs = stmt.executeQuery(sql_ideditorial);
			
			
			
			while (rs.next()){
				Usuario u = new Usuario();
				u.setId(rs.getInt("Id"));
				u.setNombre(rs.getString("Nombre"));
				u.setUsuario(rs.getString("Usuario"));
	           
				usuarios.add(u);
	            
			}
			
			con.commit();
			
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(rs != null) rs.close();
			if(stmt != null) stmt.close();
			con.setAutoCommit(true);
			if(con != null) con.close();
			
		}
		return usuarios;
	}
	public Usuario obtenerUsuarioxId(Integer id)throws SQLException{
		Usuario usuario = new Usuario();
		
		String sql_Us = "SELECT Id, Nombre, Usuario, Password FROM Usuarios WHERE Id = ?";
				
		
		PreparedStatement ps_Usuario = null;
		Connection con = null;
		ResultSet rs_Usuario = null;
		
		con = DBConn.DataSourceCon();
		try {
			ps_Usuario = con.prepareStatement(sql_Us);
			ps_Usuario.setInt(1, id); 
			
			rs_Usuario = ps_Usuario.executeQuery();
			
			while(rs_Usuario.next()){
				usuario.setId(rs_Usuario.getInt("Id"));
				usuario.setNombre(rs_Usuario.getString("Nombre"));
				usuario.setUsuario(rs_Usuario.getString("Usuario"));
				usuario.setPass(rs_Usuario.getString("Password"));
				
			}
			ps_Usuario.close();
			rs_Usuario.close();
			con.close();
			
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		
		
		return usuario;
		
	}
	
	public boolean asociarTerminalaUsuario(Integer IdUs, Integer IdT){
		
		String sql = "INSERT INTO Usuario_Terminal (Id_Terminal, Id_Usuario) VALUES(?, ?)";
				
		
		PreparedStatement ps_Us_Terminal = null;
		Connection con = null;
		@SuppressWarnings("unused")
		ResultSet rs_Us_Terminal = null;
		
		con = DBConn.DataSourceCon();
		try {
			ps_Us_Terminal = con.prepareStatement(sql);
			ps_Us_Terminal.setInt(1, IdT);
			ps_Us_Terminal.setInt(2, IdUs);
			
			ps_Us_Terminal.executeUpdate();
			
						
			ps_Us_Terminal.close();
			con.close();
			
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		finally{
			try {
				con.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		
		return true;
	}

	public ArrayList<Terminal> selectNotTerminalUsuario(Integer id_Usuario) {
		// TODO Auto-generated method stub
		ArrayList<Terminal> terminales = new ArrayList<Terminal>();
		String sql_terminales = "SELECT 	" +
				"Terminales.Id, " +
				"Terminales.Nombre, " +
				"Terminales.Domicilio, " +
				"Terminales.Telefono, " +
				"Configuracion.Valor " +
				"FROM Terminales " +
				"JOIN Configuracion ON Configuracion.Parametro='Terminal_Administrativa'" +
				"WHERE Terminales.Id " +
				"NOT IN(SELECT Id_Terminal FROM Usuario_Terminal " +
				"WHERE Id_Usuario=?)";
		
		PreparedStatement ps_terminales = null;
		Connection con = null;
		ResultSet rs_terminales = null;
		
		con = DBConn.DataSourceCon();
		try {
			con.setAutoCommit(false);
			ps_terminales = con.prepareStatement(sql_terminales);
			ps_terminales.setInt(1, id_Usuario); 
			
			rs_terminales = ps_terminales.executeQuery();
			
			while(rs_terminales.next()){
				Terminal terminal = new Terminal();
				
				terminal.setDomicilio(rs_terminales.getString("Domicilio"));
				terminal.setId(rs_terminales.getInt("Id"));
				
				if(rs_terminales.getInt("Id")==rs_terminales.getInt("Valor")){
					terminal.setNombre(rs_terminales.getString("Nombre")+"-T_Administrativa");	
				}else{
					terminal.setNombre(rs_terminales.getString("Nombre"));
				}
				
				terminal.setTelefono(rs_terminales.getString("Telefono"));
				terminales.add(terminal);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			try {
				con.commit();
				con.setAutoCommit(true);
				
				ps_terminales.close();
				rs_terminales.close();
				con.close();
				
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		return terminales;
	}
}
